// 替换函数,在页面里引入public.js后，可以调用string的replaceAll方法。
// 例如 var str="abcd";str.replaceAll("ab","cd");那么结果就是str="cdcd";
String.prototype.replaceAll = function(reallyDo, replaceWith, ignoreCase) {
	if (!RegExp.prototype.isPrototypeOf(reallyDo)) {
		return this.replace(new RegExp(reallyDo, (ignoreCase ? "gi" : "g")),
				replaceWith);
	} else {
		return this.replace(reallyDo, replaceWith);
	}
}

// 去掉空格
function public_trim(str) {
	if(str==null || str==undefined) {
		return "";
	}
	str = str + "";
	if (str == null || str == "" || str == 'undefined')
		str = "";
	//str = str.replace(/\s/g, "");
	//str = str.replace("　", "");
	str = str.replace(/(^\s*)|(\s*$)/g, "");
	return str;
}

function public_toNumber(value, defaultValue) {
	if (!public_isEmpty(value) || $.isNumeric(value)) {
		var v = Number(value) + "";
		if (v == 'NaN') {
			return defaultValue;
		}
		return Number(v);
	}
	return defaultValue;
}

function public_selectFirstTreeNode(treeId){
	var _theTagTree = mini.get(treeId);
	var node = _theTagTree.getRootNode();
	var nodes = _theTagTree.getChildNodes(node);
	if(nodes.length > 0)
		_theTagTree.selectNode(nodes[0]);
}

function public_isEmpty(str) {
	str = str + "";
	if (str == null || str == "" || str == 'undefined'
			|| public_trim(str) == "" || str == "null" || str == undefined)
		return true;
	else
		return false;
}

function public_isType(obj, type) {
	return Object.prototype.toString.call(obj) === "[object " + type + "]";
}

function public_isIn(str, strs) {
	var arr = strs.split(",");
	for (var i = 0; i < arr.length; i++) {
		if (str == arr[i]) {
			return true;
		}
	}
	return false;
}

//去掉json对象里的字符串里的的左右空格，该方法是引用传递，且该方法无返回值，若需要有返回值的方法，请调用public_trimObject方法
function public_trimJsonObject(json) {
	// 1. 变量为json对象：将key输出，value进行递归
	if (public_isType(json, "Object")) {
		for ( var key in json) {
			if (public_isType(json[key], "Array")
					|| public_isType(json[key], "Object")) {
				// alert("is obj");
				public_trimJsonObject(json[key]);
			} else if (public_isType(json[key], "String")) {
				json[key] = public_trim(json[key]);
			}
		}
	}
	// 2. 变量为json数组：逐个元素递归
	else if (public_isType(json, "Array")) {
		for (var i = 0; i < json.length; i++) {
			var jsonObj = json[i];
			if (public_isType(jsonObj, "Array")
					|| public_isType(jsonObj, "Object")) {
				// alert(i+" is arr"+jsonObj);
				public_trimJsonObject(jsonObj);
			} else if (public_isType(json[i], "String")) {
				json[i] = public_trim(json[i]);
			}
		}
	}
	// 3. 变量为简单数据类型：直接输出（递归函数的终止条件）,
	// 说明用户调用的方式有可能是直接传入string或者number的，例如是这样调用的:public_trimJsonObject("123
	// "),public_trimJsonObject(123),public_trimJsonObject(new Date())
	else if (public_isType(json, "String")) {
		// 非数组或对象时，都是值传递，这里不做任何处理，请自行处理。
		//return public_trim(json);
	}
}

//给一个对象去除空格，对象可以是json对象或者基础string类型对象，该方法有返回值
function public_trimObject(obj) {
	if(obj==null)
		return obj;
	if(public_isType(obj, "String")) {
		return public_trim(obj);
	}
	if(public_isType(obj, "Array") || public_isType(obj, "Object")) {
		public_trimJsonObject(obj);
		return obj;
	}
	return obj;
}

/**
 * 是否为正整数判断，返回true表是正整数，否则返回false
 * @param value
 * @returns {boolean}
 */
function public_isPositiveInteger(value){
	let r = /^\+?[1-9][0-9]*$/;　　//正整数
	return r.test(value);
}

/**
 * var r = /^\+?[1-9][0-9]*$/;　　//正整数
 String str = "123";
 boolean flag=r.test(str);

 "^\\d+$"　　//非负整数（正整数 + 0）
 "^[0-9]*[1-9][0-9]*$"　　//正整数
 "^((-\\d+)|(0+))$"　　//非正整数（负整数 + 0）
 "^-[0-9]*[1-9][0-9]*$"　　//负整数
 "^-?\\d+$"　　　　//整数
 "^\\d+(\\.\\d+)?$"　　//非负浮点数（正浮点数 + 0）
 "^(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*))$"　　//正浮点数
 "^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$"　　//非正浮点数（负浮点数 + 0）
 "^(-(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"　　//负浮点数
 "^(-?\\d+)(\\.\\d+)?$"　　//浮点数

 */

/*
 * 与服务器交换数据 （同步或异步）
 * @param surl 
 * @param jsonData json对象 
 * @param b 异步请求true，同步请求false
 * @param successCallbackMethod 当异步时才调用的回调函数，如果是同步的，直接取方法的返回值就可以了。
 * @return 可以在代码中直接用返回值。例如：var ret = public_getServerData("/hrp/../",{id:"1"});alert(ret.data);
 */
function public_getServerData(surl, jsonObject, b, successCallbackMethod, bStringify) {
	var retvalue;
	/*
	 * if(!isEmpty(sdata)) { sdata = sdata + "&__" + Math.random(); } else {
	 * sdata = "__" + Math.random(); }
	 */
	var tempJsonObj = public_trimObject(jsonObject);
	if(bStringify == undefined) {
		bStringify = true;
	}
	if(bStringify) {
		tempJsonObj = JSON.stringify(tempJsonObj);
	}
	$.ajax({
		type : 'POST',
		url : surl,
		data : tempJsonObj,
		dataType : "json",
		// beforeSend:ajaxLoading,//发送请求前打开进度条
		error : function(jqXHR, textStatus, errorThrown) {
			// if (confirm("与服务器通讯失败,可能需要重新登录。")) {
			// window.location = getContextPath() + "/index";
			// }
			// alert(request);
			// ajaxLoadEnd();// 关闭进度条
			//  弹出jqXHR对象的信息
			/*console.pojoContrast(jqXHR.responseText);
			console.pojoContrast(jqXHR.status);
			console.pojoContrast(jqXHR.readyState);
			console.pojoContrast(jqXHR.statusText);
            //弹出其他两个参数的信息
			console.pojoContrast(textStatus);
			console.pojoContrast(errorThrown);*/
			if (confirm("与服务器通讯失败,可能因为超时，是否重新登录？")) {
				top.location = '/'+base;
			}
		},
		cache : false,
		async : false,
		success : function(serverReturn) {
			retvalue = serverReturn;
			// ajaxLoadEnd();// 关闭进度条
			if (b) {
				successCallbackMethod(serverReturn);
			}
		}
	});
	return retvalue;
}

/*
 * 与服务器交换数据 （异步）
 * @param surl 
 * @param jsonData json对象 
 * @return 在代码中必须这样用：
   $.when(public_getServerData_by_Defer("/hrp/../",{id:"1"})).done(function(ret){
       alert(ret.data);
   });
 */
function public_getServerData_by_Defer(surl, jsonObject) {
	var defer = $.Deferred();
	var tempJsonObj = public_trimObject(jsonObject);
	$.ajax({
		type : 'POST',
		url : surl,
		data : tempJsonObj,
		dataType : "json",
		error : function(jqXHR, textStatus, errorThrown) {
			if (confirm("与服务器通讯失败,可能因为超时，是否重新登录？")) {
				top.location = '/'+base;
			}
		},
		cache : false,
		async : true,
		success : function(serverReturn) {
			defer.resolve(serverReturn)
		}
	});
	return defer.promise();
}

function public_NVL(value, defaultValue) {
	if (!public_isEmpty(value)) {
		return value;
	}
	return defaultValue;
}

/*
 * 模态框显示位置 @param windowId: 模态框id @param x : x轴的位置,x的值为：left,center,right @param
 * y : y轴的位置,y的值为: top,middle,bottom
 */
function public_showModelAtPos(windowId, x, y) {
	var win = mini.get(windowId);
	win.showAtPos(x, y);
}

/*
 * 通用根据结果弹出提示 @param ret @returns
 */
function public_showTip(ret) {
	if (ret.ok) {
		public_showOkTips(ret.message);
	} else {
		public_showErrorTips(ret.message);
	}
}

/*
 * 通用操作成功后弹出提示 @param msg @returns
 */
function public_showOkTips(msg) {
	public_showOkTips(msg,1500);
}

/*
 * 通用操作成功后弹出提示 @param msg @returns
 */
function public_showOkTips(msg,timeout) {
	mini.showTips({
		content : '<b>成功</b> <br/>' + msg,
		state : "success",
		offset : [ 0, 0 ],
		x : "top",
		y : "top",
		timeout : timeout
	});
}

/*
 * 通用操作失败后弹出提示 @param msg @returns
 */
function public_showErrorTips(msg) {
	mini.alert(msg);
}

/**
 * 获取grid选中的id数组array
 * 
 * @param gridObject
 * @returns
 */
function public_getSelectedIdArr(gridObject) {
	var rows = gridObject.getSelecteds();
	if (rows!=null && rows.length > 0) {
		var idArr = [];
		for (var i = 0, l = rows.length; i < l; i++) {
			var r = rows[i];
			idArr.push(r.id);
		}
		return idArr;
	}
	return null;
}

/**
 * 获取grid选中的id，字符串形式返回，多个用逗号分开，例如返回:1,2,3,4
 * 
 * @param gridObject
 * @returns
 */
function public_getSelectedIdStr(gridObject) {
	var idArr = public_getSelectedIdArr(gridObject);
	if (idArr != null && idArr.length > 0) {
		var id = idArr.join(',');
		return id;
	}
	return null;
}
/**
 * 四舍五入保留两位小数
 * 
 * @param flt
 * @returns
 */
function public_round2(flt) {
	/*
	if (parseFloat(flt) == flt)
		return Math.round(flt * 100) / 100;
	// 到4位小数, return Math.round(flt * 10000) / 10000;
	else
		return 0;
		*/
	return public_decimal(flt,2);
}

function public_decimal(num,v){
	var vv = Math.pow(10,v);
	return Math.round(num*vv)/vv;
}

/**
 * 将日期类型的数据转换成指定格式的字符串
 * @param date
 *            format date 日期类型数据 format 要转换成的字符串格式
 * @returns data
 */
function public_parseDateToString(date, format) {
	if (date == null || date == undefined || format == null
			|| format == undefined) {
		public_showErrorTips("日期转换错误,请与管理员联系.");
		return;
	}
	if (date instanceof Date) {
		var year = date.getFullYear() + "";
		var month = date.getMonth() + 1;
		if(month < 10) {
			month = "0" + month;
		}
		var day = date.getDate();
		if(day < 10) {
			day = "0" + day;
		}
		if (format == "YYYYMM") {
			/*// ISO: 2017-11-30T16:00:00.000Z
			var str = date.toISOString();
			var year = str.substring(0, 4);
			var month = str.substring(5, 7);*/
			var data = year + month;
			return data;
		}
		if (format == "YYYYMMDD") {
			/*// ISO: 2017-11-30T16:00:00.000Z
			var str = date.toISOString();
			var year = str.substring(0, 4);
			var month = str.substring(5, 7);
			var day = str.substring(8, 10);*/
			var data = year + month + day;
			return data;
		}
		if (format == "YYYY-MM-DD") {
			/*// ISO: 2017-11-30T16:00:00.000Z
			var str = date.toISOString();
			var year = str.substring(0, 4);
			var month = str.substring(5, 7);
			var day = str.substring(8, 10);*/
			var data = year + "-" + month + "-" + day;
			return data;
		}
		if(format == "yyyy-MM-dd HH:mm:ss"){
			var h=date.getHours();       // 获取当前小时数(0-23)
			var m=date.getMinutes();     // 获取当前分钟数(0-59)
			var s=date.getSeconds();     // 获取当前秒数(0-59)
			var data = year + "-" + month + "-" + day +" " + h + ":" + m + ":" +s;
			return data;
		}
	} else {

		return date;

	}
}

function public_parseStringToDate(str) {
	if (str == null || str == undefined) {
		public_showErrorTips("日期转换错误,请与管理员联系.");
		return null;
	}
	if(str.length==8) {
		return new Date(str.substring(0,4), Number(str.substring(5,6)) -1 , str.substring(7,8));
	} else {
		return new Date(str.replace(/-/g, '/'));
	}
}

/**
 * 根据名称查询树的节点
 * 
 * @param tree
 *            inputNameKeyId treeId 构造树的id inputNameKeyId 输入框id
 * @returns data
 */
function public_searchTreeNodeByName(treeId, inputNameKeyId) {
	var key = mini.get(inputNameKeyId).getValue();
	var tree = mini.get(treeId);
	if (key == null || key == "" || key == undefined || key == "undefined") {
		// 取消过滤
		tree.clearFilter();
	} else {
		key = key.toLowerCase();
		// 过滤 就是for查询
		tree.filter(function(node) {
			// var text = node.name ? node.name.toLowerCase() : "";
			var name = node.name;
			if (name.indexOf(key) > -1)
				return true;
		});
	}
}
/**
 * 根据formId关闭模态框
 * 
 * @param formId
 *            formId 弹出框form的id
 * @returns data
 */
function public_onCancel(formId) {
	var formModel = mini.get(formId);
	formModel.hide();
}

/**
 * 
 * 展开父节点，滚动到并选中子节点；当子节点不存在时，滚动到并选中父节点。
 * 注意mini-tree控件和mini-treeselect控件的区别。
 * @param treeId 		树ID
 * @param nodeId 		子节点ID
 * @param nodeParentId 	父节点ID
 * @returns
 */
function public_scrollToNode(treeId, nodeId, parentNodeId) {
	
	if(public_isEmpty(treeId)) {
		return;
	}
	
	if(public_isEmpty(nodeId) && public_isEmpty(parentNodeId)) {
		return;
	}
	
	var miniObj = mini.get(treeId);
	if (miniObj == null) {
		return;
	}
	var type = miniObj.type;
	var tree = null;
	if(type == "tree") {
		tree = miniObj;
		public_scrollToNode_1(tree, nodeId, parentNodeId);
	} else if(type == "treeselect") {
		tree = miniObj.tree;
		if(!public_isEmpty(nodeId)) {
			nodeId = nodeId.split(",")[0];	
		}
		if(!public_isEmpty(parentNodeId)) {
			parentNodeId = parentNodeId.split(",")[0];	
		}
		miniObj.on("showpopup", function() {
			public_scrollToNode_1(tree, nodeId, parentNodeId);
		})
	} else {
		return;
	}
}

//展开父节点parentNode，且选择子节点node
function public_scrollToNode_1(tree, nodeId, parentNodeId) {
	
	var node = public_isEmpty(nodeId) ? null : tree.getNode(nodeId);
	var parentNode = public_isEmpty(parentNodeId) ? null : tree.getNode(parentNodeId);
	
	if(node !=null && node != undefined) {
		tree.expandPath(node);
		tree.selectNode(node);
		tree.scrollIntoView(node);
		return;
	}
	
	if(parentNode !=null && parentNode != undefined) {
		tree.expandPath(parentNode);
		tree.selectNode(parentNode);
		tree.scrollIntoView(parentNode);
	}
}

/**
 * 
 * 重新加载树 并 展开父节点，滚动到并选中节点；当节点不存在时，滚动到并选中父节点。
 * 
 * @param treeId
 *            树ID
 * @param nodeId
 *            节点ID
 * @param nodeParentId
 *            父节点ID
 * @returns
 */
function public_reloadAndscrollToNode(treeId, nodeId, nodeParentId) {
	if(public_isEmpty(treeId) || public_isEmpty(nodeId) || nodeId == 0 || nodeId == -1  || public_isEmpty(nodeParentId) || nodeParentId == 0 || nodeParentId == -1 ) {
		return;
	}	
	var tree = mini.get(treeId);
	if (tree == null) {
		alert("取不到tree对象，treeId=" + treeId);
		return;
	} else {
		tree.reload(function() {
			public_scrollToNode(treeId, nodeId, nodeParentId);
			//由于客户有不合作的，在这里统一加载一下不合作的标识
			public_mCustomerTreeLoad(tree);
		});
	}
}

/** 专属客户树的加载*/
function public_mCustomerTreeLoad(tree){
	var mCustomerTreeList = tree.getList();//获取树的所有节点
	for (var i = 0; i < mCustomerTreeList.length; i++){
		var mCustomer = mCustomerTreeList[i];
		//如果客户的合作标识符为不合作，高亮红色字体且带删除线
		var jointFlagId = mCustomer.jointFlagId;
		if(!public_isEmpty(jointFlagId) && jointFlagId == 70){
			tree.setNodeText( mCustomer , "<span style='color:red;text-decoration:line-through;'>" + mCustomer.name + " （暂不合作） </span>" );
		} 
  	}
}

/**
 * -------------------------------------------------------------------------处理图片
 */

/**
 * 从服务器加载图片
 * @param imageId	img控件的id
 * @param isLarge	是否显示大图，true:显示大图，false：显示小图
 * @param fileId	要显示的图片id
 * @returns
 */
function public_loadImageFromServer(imageId,isLarge,fileId){
	var time = new Date().getTime();
	if(public_isEmpty(imageId) && public_isEmpty(fileId)){
		return ;
	}
//	console.pojoContrast(fileId)
	if(isLarge){
		$("#"+imageId).attr("src",base + "/hrp/xt/upload/controller/xtUploadFile/show?fileId="+fileId+'&time='+time);
	}else{
		$("#"+imageId).attr("src",base + "/hrp/xt/upload/controller/xtUploadFile/show?showType=small&fileId="+fileId+'&time='+time);
	}
//	console.pojoContrast($("#"+imageId));
}

/**
 * 加载图片，解决C:\fakepath\文件路径问题——通用
 * 
 * @param mythis
 *            文件对象 此值为null时,为原始状态
 * @param imageId
 *            显示的图片ID
 * @returns
 */
function public_loadImage(e, imageId) {
	if (public_isEmpty(e)) {
		$("#" + imageId).attr('src', "");
		return;
	}
	var mythis = $("#" + e.source.id + " > input:file");
	mythis = mythis[0];
	var path, clip = $("#" + imageId), FileReader = window.FileReader;
	if (FileReader) {// 浏览器处理
		var reader = new FileReader(), file = mythis.files[0];
		reader.onload = function(e) {
			clip.css("width", 250);
			clip.css("height",200);
			clip.attr("src", e.target.result);// 这里是把图片转成64位数据存入<img>中的src里
		};
		reader.readAsDataURL(file);
	}
}

var current = 0;

// 图片向左旋转
function rotatingLeftImage(imageId) {
	current = (current - 90) % 360;
	document.getElementById(imageId).style.transform = 'rotate(' + current
			+ 'deg)';
}
// 图片还原角度
function rotatingImage(imageId) {
	current = 0;
	document.getElementById(imageId).style.transform = 'rotate(' + current
			+ 'deg)';
	$("#" + imageId).css("width", initImageWidth); // 设定实际显示宽度
	$("#" + imageId).css("height", initImageHeight);

}
// 图片向右旋转
function rotatingRightImage(imageId) {
	current = (current + 90) % 360;
	document.getElementById(imageId).style.transform = 'rotate(' + current
			+ 'deg)';
}

// 初始图片宽高
var initImageWidth;
var initImageHeight;

// 图片放大
function addImageSize(imageId) {
	var w = $("#" + imageId).width();
	var h = $("#" + imageId).height();
	if (initImageWidth == null) {
		initImageWidth = w;
		initImageHeight = h;
	}
	if (w + 200 >= window.screen.width) {
		alert("图片已经是最大");
	} else {
		$("#" + imageId).css("width", (w + 200)); // 设定实际显示宽度
		$("#" + imageId).css("height", (h + 200));
	}

}
// 图片缩小
function cutImageSize(imageId) {
	var w = $("#" + imageId).width();
	var h = $("#" + imageId).height();
	if (initImageWidth == null) {
		initImageWidth = w;
		initImageHeight = h;
	}
	if (w - 200 <= 100) {
		alert("图片已经是最小");
	} else {
		$("#" + imageId).css("width", (w - 200)); // 设定实际显示宽度
		$("#" + imageId).css("height", (h - 200));
	}
}

/**
 * 包含文件的上传
 * 说明：调用此方法适用于 miniui 的mini-fileupload控件
 * 		控件的onuploadsuccess，onuploaderror，onfileselect方法需要自己写
 * @param url	与后台交互的url
 * @param fileBrowserHtmlId	上传文件的控件id
 * @param jsonObject	json对象
 * @returns
 */
function public_fileUpload(url, fileBrowserHtmlId, jsonObject) {
	var fileupload = mini.get(fileBrowserHtmlId);
	fileupload.setUploadUrl(url);
	fileupload.setPostParam(jsonObject);
	fileupload.startUpload();
}

/**
 * 包含图片上传的与服务器交换数据
 * 
 * @param url
 * @param fileBrowserHtmlId
 *            上传图片控件的id
 * @param jsonObject
 *            json对象
 * @param callback_fun
 *            拿到数据后调用的回调函数
 * @returns
 */
function public_ajaxFileUpload(url, fileBrowserHtmlId, jsonObject, callback_fun) {
	
	var myhtmlfileId = fileBrowserHtmlId;
	var inputFile = $("#" + myhtmlfileId + " > input:file")[0];
	if (myhtmlfileId == null) {
		inputFile = null;
	}
	var tempJsonObj = public_trimObject(jsonObject);
	$.ajaxFileUpload({
		url : url, // 用于文件上传的服务器端请求地址
		fileElementId : inputFile, // 文件对象
		dataType : 'comment', // 返回值类型 一般设置为json
		data : tempJsonObj,
		cache : false,
		async : false,
//		timeout : 8000, // 超时
		success : function(data, status) // 服务器成功响应处理函数
		{
			if(!public_isEmpty(data)){
				callback_fun(cutPreToObject(data));
			}
		},
		error : function(data, status, e) // 服务器响应失败处理函数
		{	
			/*console.pojoContrast(data.responseText);
			console.pojoContrast(data.status);
			console.pojoContrast(data.readyState);
			console.pojoContrast(data.statusText);
			console.pojoContrast(status);
			console.pojoContrast(e);*/
			if (confirm("与服务器通讯失败,可能因为超时，是否重新登录？")) {
				top.location = '/'+base;
			}
		},
		complete : function() {
			var jq = $("#" + myhtmlfileId + " > input:file");
			jq.before(inputFile);
			jq.remove();
		}
	});
}

/**
 * 处理被字符串
 * 
 * <pre></pre>
 * 
 * 包围的数据 eg: "
 * 
 * <pre>
 * abcd
 * </pre>
 * 
 * "——》"abcd"
 */
var cutPreToObject = function(data) {
	var retvalue;
	var start = data.indexOf(">");
	if (start != -1) {
		var end = data.indexOf("<", start + 1);
		if (end != -1) {
			data = data.substring(start + 1, end);
		}
	}
	var o = mini.decode(data);
	retvalue = o;
	return retvalue;
}

// 通过传入fileId打开新页签显示大图片
function public_showImageOfLarge(fileId) {
	if (!public_isEmpty(fileId)) {
		var openUrl = base
				+ "/hrp/xt/upload/controller/xtUploadFile/showPictrue?fileId="
				+ fileId;// 弹出窗口的url
		window.open(openUrl, "_blank");
	} else {
		alert("图片为空！");
	}
}

/**
 * -------------------------------------------------------------------------处理图片
 */

//模糊查询过滤树--通用
function public_search(inputId, treeId, isReset, isNeedReload) {
	//inputId   	输入框的Id
	//showId    	加载的树或grid的id
	//isReset   	是否为重置
	//isNeedReload	是否需要重新加载数据
	var inputValue;
	if (!isReset) {
		inputValue = mini.get(inputId).getValue();
		if(public_isEmpty(inputValue)){
			if(isNeedReload) {
				mini.get(treeId).load();
			} else {
				mini.get(treeId).clearFilter();//取消过滤
			}
			return null;
		}
		var lastLeafNode = null;
		if(isNeedReload) {
			mini.get(treeId).load(function(node) {
				mini.get(treeId).filter(function(node) {
					if (node.name.indexOf(inputValue) != -1) {
						if(mini.get(treeId).isLeaf(node))
							lastLeafNode = node;
						return true;
					}
				});
			});
		} else {
			mini.get(treeId).filter(function(node) {
				if (node.name.indexOf(inputValue) != -1) {
					if(mini.get(treeId).isLeaf(node))
						lastLeafNode = node;
					return true;
				}
			});
		}
		if(lastLeafNode != null) {
			public_scrollToNode(treeId,lastLeafNode.id,null);
		}
	} else {
		mini.get(inputId).setValue("");
		mini.get(treeId).load();
	}

}

//jquery改变样式-通用--changeCss("id", "display", "none");
function public_changeCss(whoChange, properties, value) {
	$("#"+whoChange).css(properties, value);
}

function public_changeClassCss(whoChange, properties, value) {
	$("."+whoChange).css(properties, value);
}

/*
 * 在mainTabs内添加tab并选中
 * 
 * tabName:需要显示tab的name
 * TabTitle:需要显示tab的title
 * TabUrl:需要跳转并选中页面的url
 */
function public_addMainTab(tabName,TabTitle,TabUrl) {
	if(public_isEmpty(tabName) || public_isEmpty(TabTitle) || public_isEmpty(TabUrl))
		return;
	var tabs = window.parent.mini.get("mainTabs");
	var tab = new Object;
	tab.name = tabName;
	tab.title = TabTitle;
	tab.showCloseButton = true;
	tab.url = TabUrl;
	tabs.addTab(tab);
	tabs.activeTab(tab);
}

/*
 * ids : 需要禁用的控件ID，可以传多个，采用半角逗号隔开
 * bEnabled ：是否禁用
 * bSetEmptyWhenDisabled : 禁用时是否清空
 */
function public_setEnabledByIds(ids,bEnabled,bSetEmptyWhenDisabled) {
	if(public_isEmpty(ids))
		return;
	var arr = ids.split(",");
	for(var i=0;i<arr.length;i++) {
		if(bEnabled) {
			mini.get(arr[i]).setEnabled(true);
		} else {
			mini.get(arr[i]).setEnabled(false);
			if(bSetEmptyWhenDisabled){
				mini.get(arr[i]).setValue("");
			}
		}
	}
}

/*
	对多个miniui控件进行操作，传入true为展示这个控件，传入false为不展示这个控件
*/
function public_setVisibleByIds(ids,flag){
	if(public_isEmpty(ids))
		return;
	var arr = ids.split(",");
	for(var i=0;i<arr.length;i++) {
		mini.get(arr[i]).setVisible(flag);
	}
}

/*
	对多个query控件进行操作，传入true为展示这个控件，传入false为不展示这个控件
*/
function public_setShowByIds(ids,flag){
	if(public_isEmpty(ids))
		return;
	var arr = ids.split(",");
	for(var i=0;i<arr.length;i++) {
		if (flag) {
			$("#"+arr[i]).show();
		} else {
			$("#"+arr[i]).hide();
		}
	}
}

/*
 * 关闭mini.open打开的页面.
 */
function public_closeOpenWindow() {
	window.CloseOwnerWindow();
}

/*
 * 传入一个一维数组，转化为字符串传出，采用半角逗号分隔
 */
function public_arrTostr(arr){
	if (public_isEmpty(arr)){
		return "";
	}
	var str = "";
	for (var i = 0; i < arr.length; i++){
		if (i != 0){
			str += ",";
		}
		str += arr[i];
	}
	return str;
}

/**
 * 在指定的showLogMsgId标签下面展示系统日志
 * @param tableNameValue 业务表名
 * @param tableId	业务表id
 * @param showLogMsgId 用于展示日志的标签id
 * @returns
 */
/*function public_loadLogMsg(tableNameValue,tableIdValue,showLogMsgId,isEmployeeUse) {
	if( public_isEmpty(tableIdValue) || public_isEmpty(showLogMsgId)) {
		public_showErrorTips("未获取到相关参数,请于管理员联系.")
		return;
	}
	var url = base + "/hrp/xt/pojoContrast/controller/xtBackupLogMsg/queryBackUpLogMsg";
	if(public_isEmpty(tableNameValue) && isEmployeeUse) {
		url = base + "/hrp/xt/pojoContrast/controller/xtBackupLogMsg/queryEmployeeLog";
		tableNameValue = "";
	} else {
		if(public_isEmpty(tableNameValue)) {
			public_showErrorTips("未获取到相关参数,请于管理员联系.")
			return;
		}
	}
	//初始化日志
	var ret = public_getServerData(url,{tableName : tableNameValue,tableId : tableIdValue});
	if(ret.ok) {
		var str = "";
		if(ret.data != undefined && ret.data.length > 0) {
			var data = ret.data;
			var grid = mini.get(showLogMsgId);
			grid.setData(data);
			for(var i = data.length,j=0; j < i; j++) {
				str += data[j].createTime + "  ______  " +data[j].createUserName + " :</br>" + data[j].msg + "</br>";
			}
			$("#"+showLogMsgId).html(str);
		} else {
			str = "无修改日志记录信息.";
			$("#"+showLogMsgId).html(str);
		}
	}
}*/

/**
 * inputId-span的id
 * 根据id，cacheName查到对应的name
 * @param id
 * @param cacheName
 * @returns
 */
function public_loadIdToName(inputId,cacheId,cacheName,jsonConetent){
	var name = getNameById(cacheId,cacheName,jsonConetent);
	$("#"+inputId).html(name);
}

//隐藏   （e可以为#与.）
function public_jquery_hide(e){
	$(e).hide();
}

//显示   （e可以为#与.）
function public_jquery_show(e){
	$(e).show();
}

var public_readEmployeeInfoRender = function ( e ) {
	var employeeId = e.row.employeeId;
	var employeeCustomerId = e.row.employeeCustomerId;
	var customerTypeId = e.row.customerTypeId;
	var employeeName = e.row.name;
	if(public_isEmpty(employeeId) || public_isEmpty(employeeCustomerId)){
		return e.value;
	}else{
		return ' <a href="javascript:public_readEmployeeInfo(\'' + employeeId + '\',\''+employeeCustomerId+'\',\''+customerTypeId+'\',\''+employeeName+'\')" >'+e.value+'</a>'
	}
}

function public_readEmployeeInfo(employeeId, employeeCustomerId, customerTypeId, employeeName, doOper){
	var url;
	if(customerTypeId == "291"){
		url = "/hrp/m/employee/controller/mEmployee/updateInit?employeeId=" + employeeId +"&employeeCustomerId=" + employeeCustomerId + "&doOper=6";
		//"/hrp/m/employee/controller/mEmployee/updateInit?employeeId=" + employeeId + "&customerId=" + customerId + "&doOper=6"
		//url= "/hrp/m/employee/controller/mEmployee/updateInit?employeeId=" + employeeId + "&customerId=" + customerId + "&doOper=6";
	}else if(customerTypeId == "292" || customerTypeId == "293"){
		url = "/hrp/m/employee/pa/controller/mPaEmployee/paEmployeeAllInfoInit?employeeId=" + employeeId +"&employeeCustomerId=" + employeeCustomerId +"&customerTypeId=" + customerTypeId + "&doOper=6";
		//url="/hrp/m/employee/pa/controller/mPaEmployee/forwardPaEmployeeAddInit?id="+employeeId+"&customerTypeId="+customerTypeId+"&customerId="+customerId+"&doOper=6";
	}else{
		alert("该员工所属的客户类型不正确！");
		return;
	}
	mini.open({
     	targetWindow: window.parent.parent,
         url: base + url,
         title: "员工-"+employeeName, width: 1366, height: 800,
         onload: function () {
         },
         ondestroy: function (action) {
         }
     });
}

/**
 * str或num转换成日期格式的数据
 * 
 * @param data 
 * @param format 数据格式
 * @returns
 */
function public_strParseDate (data,dataFormat) {
	if(data == undefined || data == null ) {
		return;
	}
	data = data + "";
	var value = "";
	//201801
	if(dataFormat == "YYYYMM") {
		var year = data.substring(0,4);
		var month = data.substring(4,data.length);
		var value = year + "-" + month;
	}
	return new Date(value);

}
/**
 * 清空查询条件
 * @param formId
 * @returns
 */
function public_clearQueryCondition(formId) {
	if(formId == undefined || formId == null ) {
		return;
	}
	var form=new mini.Form(formId);
	form.clear();
}

/**
 * 翻译员工在离职的图片
 * @param e
 * @returns
 */
function statusRenderer(e) {
	var s ="";
	if(e.value == 1) {
		s = "<span class='icon-ok'>&nbsp&nbsp&nbsp&nbsp</span>";
	} else {
		s = "<span class='icon-no'>&nbsp&nbsp&nbsp&nbsp</span>";
	}
    return s; 
}
//-------------------------------------------------------------------------------------------


//-------------------- idcard,name的查询结果过滤及提示 ----------------------------------
//遗留问题 1.数据全部压在浏览器 2.the_DataGrid_Result 在public里面,页面关闭以后没有清理该值,造成内存压力.
//请求参数
var the_Old_Load_Params="";
//请求url
var the_Old_Url = "";
//返回结果值
var the_DataGrid_Result = null;
//只针对load的参数只有一个data的obj的情况下进行处理
function public_onBeforeLoad(e) {
	alert("该方法已不推荐使用。111");
	var the_Load_Grid = mini.get(e.source.id);
	var params = the_Load_Grid.getLoadParams();
	params = mini.decode(params.data);
	//用现有的值与老值进行对比
	//如果老值与现有值不一致,就不取消,进行查询.
	if(the_Old_Url == the_Load_Grid.url && !public_isEmpty(the_Old_Load_Params)
			&& public_isObjEqual(the_Old_Load_Params,params)) {
		e.cancel = true;
		var pageIndex = e.data.pageIndex, pageSize = e.data.pageSize;
		public_fillData(pageIndex, pageSize, the_DataGrid_Result, the_Load_Grid);
        return;
	} 
	//记录每次请求的参数以及url
	the_Old_Load_Params = params;
	the_Old_Url = the_Load_Grid.url;
}

//比较2个对象是否相同  
function public_isObjEqual(obj1,obj2){  
    var props1 = Object.getOwnPropertyNames(obj1);  
    var props2 = Object.getOwnPropertyNames(obj2);
    if (props1.length != props2.length) {  
        return false;  
    }  
    for (var i = 0,max = props1.length; i < max; i++) {  
        var propName = props1[i];  
        if (obj1[propName] !== obj2[propName]) {  
            return false;  
        }  
    }  
    return true;  
} 

// 分页填充细节处理
function public_fillData(pageIndex, pageSize, dataResult, grid) {
    var data = dataResult.data, totalCount = dataResult.total;
    var arr = [];
    var start = pageIndex * pageSize, end = start + pageSize;
    for (var i = start, l = end; i < l; i++) {
        var record = data[i];
        if (!record) 
        	continue;
        arr.push(record);
    }
    grid.setTotalCount(totalCount);
    grid.setPageIndex(pageIndex);
    grid.setPageSize(pageSize);
    grid.setData(arr);
  //隐藏查询的钟罩
	mini.hideMessageBox(theMask);
}

/*
*通用方法显示idCard,name的提示信息
*
*gridId:gridId
*keyForm:获取查询条件的formid
*showSearchMsgId: 显示提示信息的id
*
*/
var  public_searchAndCheckData = function(gridId,keyFormId,showSearchMsgId) {
	alert("该方法已不推荐使用。222");
	var employeeGrid = mini.get(gridId);
	var form = new mini.Form("#"+keyFormId);
	var data = form.getData(true);
	var flag = public_attributeIsAllNull(data);
	if(flag){
		mini.alert("请输入查询条件！");
		return;
	}
	data.iLoveFzzlRandomTime = new Date().getTime(); // 加个随机时间防止界面不做查询，进度条假装卡死
	data.checkIdCardOrName = true;
	data = mini.encode(data);
	//查询的钟罩
	theMask = mini.loading("正在查询中，请稍后...");
	employeeGrid.load({data : data},function(e) {
		alert(333);
		//隐藏查询的钟罩
		mini.hideMessageBox(theMask);
		$("#"+showSearchMsgId).html("");
		if(e.result.resultCheckValue == undefined )
			return; 
		var grid = mini.get(e.sender.id);
		public_fillData(e.pageIndex,e.pageSize,e,grid);
		var result = e.result;
		//给全局变量赋值,用于之后的分页
		the_DataGrid_Result = result;
		var resultValue = result.resultCheckValue;
		var idNotStr = "************根据您的查询条件有找不到的身份证：************</br>";
		var idRepStr = "**************您的查询条件有重复身份证的：**************</br>";
		var nameNotStr = "-------------根据您的查询条件有找不到的姓名：-------------</br>";
		var nameRepStr = "---------------您的查询条件有重复姓名的：-----------------</br>";
		var commonStr = "无数据.</br>";
		//idCard不在查询结果的
		if(!public_isEmpty(resultValue.idNotInStr)) {
			idNotStr += resultValue.idNotInStr;
		} else {
			idNotStr += commonStr;
		}
		//idCard查询值重复的
		if(!public_isEmpty(resultValue.idRepeatingValue)) {
			idRepStr += resultValue.idRepeatingValue;
		} else {
			idRepStr += commonStr;
		}
		//name不在查询结果的
		if(!public_isEmpty(resultValue.nameNotInStr)) {
			nameNotStr += resultValue.nameNotInStr;
		} else {
			nameNotStr += commonStr;
		}
		//name查询值重复的
		if(!public_isEmpty(resultValue.nameRepeatingValue)) {
			nameRepStr += resultValue.nameRepeatingValue;
		} else {
			nameRepStr += commonStr;
		}
		idNotStr ="</br>" + idNotStr + idRepStr + nameNotStr + nameRepStr;
		$("#"+showSearchMsgId).html(idNotStr);
	}); 
}

//--------------------------------------------------------------------------------------------------

var public_welfareStatusRender = function (e) {
	var returnStr;
	var s=e.value;
	if(s == null){
		s = '未申报'
	}else{
		s = getNameById(s,"xt_dic");
	}
    return s;
}

/**
* 如果数组中的值包含字符串，移除，返回不包含该字符串的数组
*	arr		数组
*	str		字符串
*	曾婷
*/
function public_removeStrInArr(arr, str){
	var index = 0;
	var returnArr = new Array();
	for (var i = 0; i < arr.length; i++){
		var value = arr[i];
		var iscontaintest = value.search(str) == -1 ? false : true;
		if(!iscontaintest){
			returnArr[index] = value;
			index++;
		}
  	}
	return returnArr;
}

/**
 * 判断一个对象身上是否所有的属性都为空
 * @param obj
 * @param IgnoreKeys 忽略key值列表，多个用半角逗号分隔
 * @returns
 */
function public_attributeIsAllNull(obj){
	var tmp = [];
	for(var key in obj){
		if(key=="isCheckResultRepeat") {
			continue;
		}
		if(!public_isEmpty(obj[key])){
			tmp.push(obj[key]);
		}
	}
	if(tmp.length <= 0){
		return true;
	}
	return false;
}

//金额的格式，1000.00
function public_moneyRenderer(e){
	var s = e.value;
	return "<span style='color:black;'>" + mini.formatNumber(s,"#,0.00") + "</span>";
}

//禁止选中父节点
function public_isLeaf(e) {
	if (e.isLeaf == false){
		e.cancel = true;
	}
}

/*
 * 通用表格加载方法
 * @param gridId					Grid页面ID
 * @param conditionFormId			查询条件表单ID
 * @param bMustInputOneCondition	是否至少输入一个查询条件
 */
function public_loadGrid(gridId, conditionFormId, bMustInputOneCondition) {
	var gridObj = mini.get(gridId);
	var formObj = new mini.Form("#" + conditionFormId);
	var data = formObj.getData(true);
	if(bMustInputOneCondition && public_attributeIsAllNull(data)){
		mini.alert("请输入查询条件！");
		return;
	}
	//查询的钟罩
	//theMask = mini.loading("正在查询中，请稍后...");
	//console.pojoContrast(theMask)
	data.iLoveFzzlRandomTime = new Date().getTime(); // 加个随机时间防止界面不做查询
	data.checkIdCardOrName = false;
	gridObj.load(data,
		function(e) {
			//隐藏查询的钟罩
			//mini.hideMessageBox(theMask);		
		}
	);
}

/*
 * 通用表格加载方法，并且校验结果集是否有重复姓名或者身份证号码。
 * 处理机制：
 * 1，先按正常分页查询表格数据；
 * 2，二次发送查询请求到服务器，检查重复性。（异步方式）
 * 好处：1，浏览器数据堆积压力减少；2，检查重复性通过异步的方式能提高浏览器相应速度。
 * @param gridId					Grid页面ID
 * @param conditionFormId			查询条件表单ID
 * @param bMustInputOneCondition	是否至少输入一个查询条件
 * @param bCheckResultRepeat		是否对查询结果检查重复姓名或者身份证号码
 * @param showSearchMsgId			重复性校验信息的DIV ID
 */
function public_loadGridAndCheckResultRepeat(gridId, conditionFormId, bMustInputOneCondition, bCheckResultRepeat, showSearchMsgId) {
	public_loadGrid(gridId, conditionFormId, bMustInputOneCondition);
	if(bCheckResultRepeat) {
		public_checkResultRepeat(gridId, conditionFormId, bMustInputOneCondition, showSearchMsgId);	
	} else {
		$("#"+showSearchMsgId).html("不对查询结果检查重复姓名。如果要检查，您可以把查询条件【是否对查询结果检查重复姓名】选择为是，再重新执行查询。");
	}
}

//检查表格结果是否有重复的姓名或者身份证号码
function public_checkResultRepeat(gridId, conditionFormId, bMustInputOneCondition, showSearchMsgId) {
	var gridObj = mini.get(gridId);
	var formObj = new mini.Form("#" + conditionFormId);	
	var data = formObj.getData(true);
	if(bMustInputOneCondition && public_attributeIsAllNull(data)){
		return;
	}
	theMask = mini.loading("正在检查结果是否有重复姓名或身份证，请稍后...");
	data.checkIdCardOrName = true;
    $.when(public_getServerData_by_Defer(gridObj.url,data)).done(function(ret){
		var nameConditionRepeating = "--------------姓名查询条件有重复的：--------------</br>";
		var nameNotInResult = "--------------姓名查询条件有找不到的：--------------</br>";
		var nameResultRepeating = "--------------姓名查询结果有重复的：--------------</br>";
		var idCardConditionRepeating = "************身份证查询条件有重复的：************</br>";
		var idCardNotInResult = "**************身份证查询条件有找不到的：**************</br>";
		var idCardResultRepeating = "**************身份证查询结果有重复的：**************</br>";
		var commonStr = "无数据.</br>";
		//console.pojoContrast(ret);
		var resultValue = ret.resultCheckValue;
		
		if(!public_isEmpty(resultValue.nameConditionRepeating)) {
			nameConditionRepeating += resultValue.nameConditionRepeating;
		} else {
			nameConditionRepeating += commonStr;
		}
		if(!public_isEmpty(resultValue.nameNotInResult)) {
			nameNotInResult += resultValue.nameNotInResult;
		} else {
			nameNotInResult += commonStr;
		}
		if(!public_isEmpty(resultValue.nameResultRepeating)) {
			nameResultRepeating += resultValue.nameResultRepeating;
		} else {
			nameResultRepeating += commonStr;
		}
		
		
		if(!public_isEmpty(resultValue.idCardConditionRepeating)) {
			idCardConditionRepeating += resultValue.idCardConditionRepeating;
		} else {
			idCardConditionRepeating += commonStr;
		}
		if(!public_isEmpty(resultValue.idCardNotInResult)) {
			idCardNotInResult += resultValue.idCardNotInResult;
		} else {
			idCardNotInResult += commonStr;
		}
		if(!public_isEmpty(resultValue.idCardResultRepeating)) {
			idCardResultRepeating += resultValue.idCardResultRepeating;
		} else {
			idCardResultRepeating += commonStr;
		}
		var html ="</br>" + nameConditionRepeating + nameNotInResult + nameResultRepeating + idCardConditionRepeating + idCardNotInResult + idCardResultRepeating;
		$("#"+showSearchMsgId).html(html);
		mini.hideMessageBox(theMask);
	});
}